#include <string.h>
#include <time.h>
#include <sys/time.h>
#include <stdarg.h>
#include "log.h"
#include <pthread.h>
using namespace std;

Log::Log()
{
    m_count = 0;
    m_is_async = false;
}

Log::~Log()
{
    printf("~Log\n");
    if(m_fp != NULL)
    {
        fclose(m_fp);
    }
}

void *Log::async_write_log()
{
    string single_log;
    while(m_log_queue->pop(single_log))
    {
        std::unique_lock<std::mutex> uniqueLock(m_mutex);
        fputs(single_log.c_str(), m_fp);
    }

    return nullptr;
}

Log *Log::get_instance()
{
    static Log instance;
    return &instance;
}

void *Log::flush_log_thread(void *args)
{
    (void)args;
    Log::get_instance()->async_write_log();
    return nullptr;
}

bool Log::init(const char* file_name, int log_buf_size, int split_lines, int max_queue_size)
{
    if(max_queue_size >= 1)
    {
        m_is_async = true;
        m_log_queue = new block_queue<string>(max_queue_size);
        pthread_t tid;
        pthread_create(&tid, NULL, flush_log_thread, NULL);
    }

    m_log_buf_size = log_buf_size;
    m_buf = new char[m_log_buf_size];
    memset(m_buf, '\0', m_log_buf_size);
    m_split_lines = split_lines;

    time_t t = time(NULL);
    struct tm* sys_tm = localtime(&t);
    struct tm my_tm = *sys_tm;
    const char *p = strrchr(file_name, '/');
    char log_full_name[256] = {0};
    if(p == NULL)
    {
        snprintf(log_full_name, 255, "%d_%02d_%02d_%s",my_tm.tm_year+1900, my_tm.tm_mon+1, my_tm.tm_mday, file_name);
    }
    else
    {
        strcpy(log_name, p+1);
        strncpy(dir_name, file_name, p - file_name + 1);
        snprintf(log_full_name, 255, "%s%d_%02d_%02d_%s",dir_name, my_tm.tm_year+1900, my_tm.tm_mon+1, my_tm.tm_mday, log_name );
    }

    m_today = my_tm.tm_mday;

    printf("log_full_name: %s\n", log_full_name);
    m_fp = fopen(log_full_name, "a");
    if(m_fp == NULL)
    {
        return false;
    }

    return true;
}

void Log::write_log(int level, const char* format, ...)
{
    struct timeval now = {0,0};
    gettimeofday(&now, NULL);
    time_t t = now.tv_sec;
    struct tm* sys_tm = localtime(&t);
    struct tm my_tm = *sys_tm;
    char s[16] = {0};
    switch(level)
    {
        case 0 : strcpy(s, "[debug]:"); break;
        case 1 : strcpy(s, "[info]:"); break;
        case 2 : strcpy(s, "[warn]:"); break;
        case 3 : strcpy(s, "[erro]:"); break;
        default:
               strcpy(s, "[info]:"); break;
    }

    std::unique_lock<std::mutex> uniqueLock(m_mutex);
    m_count++;
    if(m_today != my_tm.tm_mday || m_count % m_split_lines == 0) //everyday log
    {
        char new_log[256] = {0};
        fflush(m_fp);
        fclose(m_fp);
        char tail[16] = {0};
        snprintf(tail, 16,  "%d_%02d_%02d_", my_tm.tm_year+1900, my_tm.tm_mon+1, my_tm.tm_mday);
        if(m_today != my_tm.tm_mday)
        {
            snprintf(new_log, 255, "%s%s%s", dir_name, tail, log_name);
            m_today = my_tm.tm_mday;
            m_count = 0;
        }
        else
        {
//            snprintf(new_log, 255, "%s%s%s.%lld", dir_name, tail, log_name, m_count/m_split_lines);
            snprintf(new_log, 255, "%s%s%s", dir_name, tail, log_name);
        }

        printf("newLog: %s\n", new_log);

        m_fp = fopen(new_log, "a");
    }
    uniqueLock.unlock();

    va_list valst;
    va_start(valst, format);

    string log_str;
    uniqueLock.lock();

    int n = snprintf(m_buf, 48, "%d-%02d-%02d %02d:%02d:%02d.%06ld %s ",
            my_tm.tm_year+1900, my_tm.tm_mon+1, my_tm.tm_mday,
            my_tm.tm_hour, my_tm.tm_min, my_tm.tm_sec, now.tv_usec, s);
    int m = vsnprintf(m_buf + n, m_log_buf_size-1, format, valst);
    m_buf[n + m - 1] = '\n';
    log_str = m_buf;
    printf("log_str: %s\n", log_str.c_str());

    uniqueLock.unlock();

    if(m_is_async && !m_log_queue->full())
    {
        m_log_queue->push(log_str);
    }
    else
    {
        uniqueLock.lock();
        fputs(log_str.c_str(), m_fp);
        fflush(m_fp);           // 刷新文件
        uniqueLock.unlock();
    }

    va_end(valst);
}

void Log::flush(void)
{
    std::unique_lock<std::mutex> uniqueLock(m_mutex);
    fflush(m_fp);
}
